use std::fmt;

use log::error;
use serde::{
    Deserialize, Deserializer,
    de::{self},
};

#[inline]
pub fn opt_strs2vec(input: &Option<String>) -> Option<Vec<String>> {
    match input {
        Some(input) => {
            let trimmed = input.trim();
            if trimmed.is_empty() {
                Some(Vec::new())
            } else {
                Some(trimmed.split(',').map(|s| s.to_string()).collect())
            }
        }
        None => None,
    }
}

pub fn deserialize_strs<'de, D>(deserializer: D) -> Result<Option<Vec<String>>, D::Error>
where
    D: Deserializer<'de>,
{
    let s: Option<String> = Option::deserialize(deserializer)?;
    if let Some(s) = s {
        error!("s {}", s);
        let s = s.trim();
        if s.len() <= 0 {
            return Ok(None);
        }
        let cols: Vec<String> = s.split(',').map(|s| s.trim().to_string()).filter(|s| !s.is_empty()).collect();
        Ok(Some(cols))
    } else {
        Ok(None)
    }
}

// 自定义访问器：处理tag_ids[]的各种情况（单值、多值、空值）
struct TagIdsVisitor;

impl<'de> de::Visitor<'de> for TagIdsVisitor {
    type Value = Option<Vec<String>>;

    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("one or more tag_ids[] values or empty")
    }

    // 处理单个字符串值（如tag_ids[]=123）
    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
    where
        E: de::Error,
    {
        error!("visit_str {}", v);
        let trimmed = v.trim();
        if trimmed.is_empty() {
            Ok(None) // 空字符串视为None
        } else {
            Ok(Some(vec![trimmed.to_string()]))
        }
    }

    // 处理字符串数组（如多个tag_ids[]参数）
    fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
    where
        A: de::SeqAccess<'de>,
    {
        let mut values = Vec::new();
        while let Some(value) = seq.next_element::<String>()? {
            let trimmed = value.trim();
            error!("trimmed {}", trimmed);
            if !trimmed.is_empty() {
                values.push(trimmed.to_string());
            }
        }
        Ok(if values.is_empty() { None } else { Some(values) })
    }

    // 处理None情况（参数不存在时）
    fn visit_none<E>(self) -> Result<Self::Value, E>
    where
        E: de::Error,
    {
        Ok(None)
    }

    // 处理Some(T)情况（参数存在但值为空）
    fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
    where
        D: Deserializer<'de>,
    {
        deserializer.deserialize_any(self)
    }
}

// 自定义反序列化函数：兼容重复字段和各种格式
pub fn deserialize_vec<'de, D>(deserializer: D) -> Result<Option<Vec<String>>, D::Error>
where
    D: Deserializer<'de>,
{
    // 使用deserialize_any确保所有情况都能被正确处理
    deserializer.deserialize_any(TagIdsVisitor)
}
